// https://github.com/DeepElement/markdown-it-plantuml-offline

export default function umlPlugin (md, options) {
  function generateSourceDefault (umlCode, pluginOptions) {
    return 'api/plantuml/png?data=' + encodeURIComponent(umlCode)
  }

  options = options || {}

  var openMarker = options.openMarker || '@startuml'
  var openChar = openMarker.charCodeAt(0)
  var closeMarker = options.closeMarker || '@enduml'
  var closeChar = closeMarker.charCodeAt(0)
  var render = options.render || md.renderer.rules.image
  var generateSource = options.generateSource || generateSourceDefault
  var loadingSrc = ''

  function uml (state, startLine, endLine, silent) {
    var nextLine
    var markup
    var params
    var token
    var i
    var autoClosed = false
    var start = state.bMarks[startLine] + state.tShift[startLine]
    var max = state.eMarks[startLine]

    // Check out the first character quickly,
    // this should filter out most of non-uml blocks
    //
    if (openChar !== state.src.charCodeAt(start)) { return false }

    // Check out the rest of the marker string
    //
    for (i = 0; i < openMarker.length; ++i) {
      if (openMarker[i] !== state.src[start + i]) { return false }
    }

    markup = state.src.slice(start, start + i)
    params = state.src.slice(start + i, max)

    // Since start is found, we can report success here in validation mode
    //
    if (silent) { return true }

    // Search for the end of the block
    //
    nextLine = startLine

    for (;;) {
      nextLine++
      if (nextLine >= endLine) {
        // unclosed block should be autoclosed by end of document.
        // also block seems to be autoclosed by end of parent
        break
      }

      start = state.bMarks[nextLine] + state.tShift[nextLine]
      max = state.eMarks[nextLine]

      if (start < max && state.sCount[nextLine] < state.blkIndent) {
        // non-empty line with negative indent should stop the list:
        // - ```
        //  test
        break
      }

      if (closeChar !== state.src.charCodeAt(start)) {
        // didn't find the closing fence
        continue
      }

      if (state.sCount[nextLine] > state.sCount[startLine]) {
        // closing fence should not be indented with respect of opening fence
        continue
      }

      var closeMarkerMatched = true
      for (i = 0; i < closeMarker.length; ++i) {
        if (closeMarker[i] !== state.src[start + i]) {
          closeMarkerMatched = false
          break
        }
      }

      if (!closeMarkerMatched) {
        continue
      }

      // make sure tail has spaces only
      if (state.skipSpaces(start + i) < max) {
        continue
      }

      // found!
      autoClosed = true
      break
    }

    var contents = state.src
      .split('\n')
      .slice(startLine + 1, nextLine)
      .join('\n')

    // We generate a token list for the alt property, to mimic what the image parser does.
    var altToken = []
    // Remove leading space if any.
    var alt = params ? params.slice(1) : 'uml diagram'
    state.md.inline.parse(
      alt,
      state.md,
      state.env,
      altToken
    )

    token = state.push('uml_diagram', 'img', 0)
    // alt is constructed from children. No point in populating it here.

    var imgSrc = generateSource(contents, options)
    token.attrs = [
      ['src', loadingSrc],
      ['data-plantuml-src', imgSrc],
      ['alt', '']
    ]
    token.block = true
    token.children = altToken
    token.info = params
    token.map = [ startLine, nextLine ]
    token.markup = markup

    state.line = nextLine + (autoClosed ? 1 : 0)

    return true
  }

  md.block.ruler.before('fence', 'uml_diagram', uml, {
    alt: [ 'paragraph', 'reference', 'blockquote', 'list' ]
  })
  md.renderer.rules.uml_diagram = render
}
